home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / tmpas / pascode.pt < prev    next >
Text File  |  1990-10-02  |  17KB  |  751 lines

  1. .. file: pascode.pt
  2. ..
  3. .. The following variables must be set in tm:
  4. .. basename:     the name of the module. used to generate Stat..
  5. .. wantdefs:     the names of wanted definitions.
  6. { ---- start of ${tplfilename} ---- }
  7.  
  8. { routines for $(basename).
  9.  
  10.   template file:      ${tplfilename}
  11.   datastructure file: ${dsfilename}
  12.   tm version:         $(tmvers) ($(tmdate))
  13. }
  14.  
  15. {********************************************************************
  16.  *    New<type> and New<cons> functions                             *
  17.  ********************************************************************}
  18.  
  19. .foreach t $(need_New)
  20. .if ${len ${telmlist $t}}
  21. { Allocate a new instance of tuple type '$t' }
  22. procedure New$t(
  23. .foreach sname ${telmlist $t}
  24. .if ${eq list ${ttypeclass $t $(sname)}}
  25.  Tmp$(sname): ${ttypename $t $(sname)}list;
  26. .else
  27.  Tmp$(sname): ${ttypename $t $(sname)};
  28. .endif
  29. .endforeach
  30.  var nw: $t
  31. );
  32. begin
  33.     new( nw );
  34. .if ${index Stat$(basename) $(need_misc)}
  35.     CntNew$t := CntNew$t+1;
  36. .endif
  37.     nw^.next:=nil;
  38. .foreach sname ${telmlist $t}
  39.     nw^.$(sname) := Tmp$(sname);
  40. .endforeach
  41. end; { New$t }
  42.  
  43. .else
  44. .foreach c ${conslist $t}
  45. { Allocate a new instance of constructor '$c' }
  46. procedure New$c(
  47. .foreach sname ${celmlist $t $c}
  48. .if ${eq list ${ctypeclass $t $c $(sname)}}
  49.  Tmp$(sname): ${ctypename $t $c $(sname)}list;
  50. .else
  51.  Tmp$(sname): ${ctypename $t $c $(sname)};
  52. .endif
  53. .endforeach
  54.  var nw: $t
  55. );
  56. begin
  57.     new( nw, Tag$c );
  58.     nw^.tag := Tag$c;
  59.     nw^.next :=nil;
  60. .foreach sname ${celmlist $t $c}
  61.     nw^.$(sname) := Tmp$(sname);
  62. .endforeach
  63. .if ${index Stat$(basename) $(need_misc)}
  64.     CntNew$c := CntNew$c+1;
  65. .endif
  66. end; { New$c }
  67.  
  68. .endforeach
  69. .endif
  70. .endforeach
  71.  
  72. {*******************************************************************
  73.  *   Free<type> and Free<type>list routines                        *
  74.  *******************************************************************}
  75.  
  76. { Forward declarations }
  77. .foreach t $(need_Free)
  78. procedure Free$t( var e: $t  ); forward;
  79. .endforeach
  80. .foreach t $(need_Free_list)
  81. procedure Free$tlist( var l: $tlist ); forward;
  82. .endforeach
  83.  
  84. .foreach t $(need_Free)
  85. { dispose an element of type $t }
  86. procedure Free$t;
  87. begin
  88.     if (e <> nil) then begin
  89. .if ${len ${telmlist $t}}
  90. .if ${index Stat$(basename) $(need_misc)}
  91.     CntFre$t := CntFre$t+1;
  92.     dispose( e );
  93. .endif
  94. .else
  95.     case e^.tag of
  96. .foreach c ${conslist $t}
  97.         Tag$c: begin
  98. .if ${index Stat$(basename) $(need_misc)}
  99.         CntFre$c := CntFre$c+1;
  100. .endif
  101.         dispose( e, Tag$c );
  102.         end;
  103. .endforeach
  104.     end;
  105. .endif
  106.     end
  107. end; { Free$t }
  108.  
  109. .endforeach
  110. .foreach t $(need_Free_list)
  111. { free a list of $t elements }
  112. procedure Free$tlist;
  113. var
  114.     h1: $tlist;
  115.     h2: $tlist;
  116. begin
  117.     h1:=l;
  118.     while h1<>nil do begin
  119.     h2:=h1^.next;
  120.     Free$t( h1 );
  121.     h1:=h2
  122.     end;
  123.     l := nil
  124. end; (* Free$tlist *)
  125.  
  126. .endforeach
  127.  
  128. {*******************************************************************
  129.  *    Rfre<type> and Rfre<type>list routines                       *
  130.  *******************************************************************}
  131.  
  132. { Forward declarations }
  133. .foreach t $(need_Rfre)
  134. procedure Rfre$t( var e: $t ); forward;
  135. .endforeach
  136. .foreach t $(need_Rfre_list)
  137. procedure Rfre$tlist( var l: $tlist ); forward;
  138. .endforeach
  139.  
  140. .foreach t $(need_Rfre)
  141. { Recursively free an element of type '$t'
  142.    and all elements in it.
  143. }
  144. procedure Rfre$t;
  145. begin
  146.     if (e <> nil ) then begin
  147. .if ${len ${telmlist $t}}
  148. .foreach sname ${telmlist $t}
  149. .if ${eq list ${ttypeclass $t $(sname)}}
  150.     Rfre${ttypename $t $(sname)}list( e^.$(sname) );
  151. .else
  152.     Rfre${ttypename $t $(sname)}( e^.$(sname) );
  153. .endif
  154. .endforeach
  155. .else
  156.     case e^.tag of
  157. .foreach c ${conslist $t}
  158.         Tag$c:
  159.         begin
  160. .foreach sname ${celmlist $t $c}
  161. .if ${eq list ${ctypeclass $t $c $(sname)}}
  162.         Rfre${ctypename $t $c $(sname)}list( e^.$(sname) );
  163. .else
  164.         Rfre${ctypename $t $c $(sname)}( e^.$(sname) );
  165. .endif
  166. .endforeach
  167.         end;
  168.  
  169. .endforeach
  170.     end;
  171. .endif
  172.     Free$t( e )
  173.     end
  174. end; { Rfre$t }
  175.  
  176. .endforeach
  177. .foreach t $(need_Rfre_list)
  178. { Recursively free a list of elements of type $t }
  179. procedure Rfre$tlist;
  180. var
  181.     h1: $tlist;
  182.     h2: $tlist;
  183.  
  184. begin
  185.     h1:=l;
  186.     while h1<>nil do begin
  187.     h2:=h1^.next;
  188.     Rfre$t( h1 );
  189.     h1:=h2
  190.     end;
  191.     l := nil
  192. end; { Free$tlist }
  193.  
  194. .endforeach
  195.  
  196. {*******************************************************************
  197.  *    App<type> functions                                          *
  198.  *******************************************************************}
  199.  
  200. .foreach t $(need_App)
  201. { Append an element after a list of type $t }
  202. function App$t( var list: $tlist; element: $t ): $tlist;
  203. var h: $t;
  204. begin
  205.     if list=nil then
  206.     App$t:=element
  207.     else begin
  208.     h:=list;
  209.     while h^.next<>nil do h:=h^.next;
  210.     h^.next:=element;
  211.     App$t := list
  212.    end
  213. end; { App$t }
  214.  
  215. .endforeach
  216.  
  217. {*******************************************************************
  218.  *    Write<type>, Write<cons> and Write<type>list routines           *
  219.  *******************************************************************}
  220.  
  221. { Forward declarations }
  222. .foreach t $(need_Write)
  223. procedure Write$t( var f: text; t: $t ); forward;
  224. .endforeach
  225. .foreach t $(need_Write_list)
  226. procedure Write$tlist( var f: text; l: $tlist ); forward;
  227. .endforeach
  228.  
  229. .foreach t $(need_Write)
  230. { Print an element of type '$t'. }
  231. procedure Write$t;
  232. begin
  233.     if ( t=nil ) then
  234.     writeln( f, '<nil>' )
  235.     else begin
  236. .if ${len ${telmlist $t}}
  237.     write( f, '(' );
  238. .set first 1
  239. .foreach sname ${telmlist $t}
  240. .if $(first)
  241. .set first 0
  242. .else
  243.     write( f, ',' );
  244. .endif
  245. .if ${eq list ${ttypeclass $t $(sname)}}
  246.     Write${ttypename $t $(sname)}list( f, t^.$(sname) );
  247. .else
  248.     Write${ttypename $t $(sname)}( f, t^.$(sname) );
  249. .endif
  250. .endforeach
  251.     writeln( f, ')' );
  252.     end
  253. .else
  254.     write( f, '(' );
  255.     case t^.tag of
  256. .foreach c ${conslist $t}
  257.         Tag$c:
  258.         begin
  259.         write( f, '$c' );
  260. .foreach sname ${celmlist $t $c}
  261.         write( f, ' ' );
  262. .if ${eq list ${ctypeclass $t $c $(sname)}}
  263.         Write${ctypename $t $c $(sname)}list( f, t^.$(sname) );
  264. .else
  265.         Write${ctypename $t $c $(sname)}( f, t^.$(sname) );
  266. .endif
  267. .endforeach
  268.         end;
  269.  
  270. .endforeach
  271.     end
  272.     end;
  273.     writeln( f, ')' );
  274. .endif 
  275. end; { Write$t }
  276.  
  277. .endforeach
  278. .foreach t $(need_Write_list)
  279. { Print list of elements of type '$t' to file 'f' }
  280. procedure Write$tlist;
  281. var
  282.     p: $t;
  283.  
  284. begin
  285.     p := l;
  286.     write( f, '[' );
  287.     while p<>nil do begin
  288.     Write$t( f, p );
  289.     p:=p^.next;
  290.     if( p<>nil ) then
  291.         write( f, ',' );
  292.     end;
  293.     writeln( f, ']' )
  294. end; { Write$tlist}
  295.  
  296. .endforeach
  297. {*******************************************************************
  298.  *    Copy<type> and Copy<type>list routines                       *
  299.  *******************************************************************}
  300.  
  301. { Forward declarations }
  302. .foreach t $(need_Copy)
  303. function Copy$t( i: $t ): $t; forward;
  304. .endforeach
  305. .foreach t $(need_Copy_list)
  306. function Copy$tlist( i: $tlist ): $tlist; forward;
  307. .endforeach
  308.  
  309. .foreach t $(need_Copy)
  310. { Recursively duplicate instance `i' of type `$t'
  311.   and all elements in it. }
  312. function Copy$t;
  313. .if ${len ${telmlist $t}}
  314. .. Copy tuple
  315. var
  316. .foreach e ${telmlist $t}
  317. .if ${eq list ${ttypeclass $t $e}}
  318.     tmp$e: ${ttypename $t $e}list;
  319. .else
  320.     tmp$e: ${ttypename $t $e};
  321. .endif
  322. .endforeach
  323.     out: $t;
  324.  
  325. begin
  326.     if ( i=nil ) then
  327.     out := nil
  328.     else begin
  329. .foreach e ${telmlist $t}
  330. .if ${eq list ${ttypeclass $t $e}}
  331.     tmp$e := Copy${ttypename $t $e}list( i^.$e );
  332. .else
  333.     tmp$e := Copy${ttypename $t $e}( i^.$e );
  334. .endif
  335. .endforeach
  336.     New$t( ${suffix ", " ${prefix "tmp" ${telmlist $t}}} out )
  337.     end;
  338.     Copy$t := out
  339. .else
  340. .. Copy constructor
  341. var
  342.     out: $t;
  343.  
  344. .foreach c ${conslist $t}
  345.     function Copy$c( i: $t ): $t;
  346.     var
  347. .foreach e ${celmlist $t $c}
  348. .if ${eq list ${ctypeclass $t $c $e}}
  349.     tmp$e: ${ctypename $t $c $e}list;
  350. .else
  351.     tmp$e: ${ctypename $t $c $e};
  352. .endif
  353. .endforeach
  354.         out : $t;
  355.  
  356.     begin
  357. .foreach e ${celmlist $t $c}
  358. .if ${eq list ${ctypeclass $t $c $e}}
  359.     tmp$e := Copy${ctypename $t $c $e}list( i^.$e );
  360. .else
  361.     tmp$e := Copy${ctypename $t $c $e}( i^.$e );
  362. .endif
  363. .endforeach
  364.     New$c( ${suffix ", " ${prefix "tmp" ${celmlist $t $c}}} out );
  365.     Copy$c := out
  366.     end; { Copy$c }
  367.  
  368. .endforeach
  369. begin
  370.     if ( i=nil ) then
  371.     out := nil
  372.     else begin
  373.     case i^.tag of
  374. .foreach c ${conslist $t}
  375.         Tag$c: out:= Copy$c( i );
  376. .endforeach
  377.     end
  378.     end;
  379.     Copy$t := out
  380. .endif
  381. end; { Copy$t }
  382.  
  383. .endforeach
  384. .foreach t $(need_Copy_list)
  385. { recursively duplicate an instance of a `$t' list }
  386. function Copy$tlist;
  387. var
  388.     out: $tlist;
  389.     prev: $tlist;
  390.  
  391. begin
  392.     if (i=nil) then
  393.     out:=nil
  394.     else begin
  395.     out := Copy$t( i );
  396.     prev := out;
  397.     i := i^.next;
  398.     while i <> nil do begin
  399.         prev^.next := Copy$t( i );
  400.         prev := prev^.next;
  401.         i := i^.next;
  402.     end;
  403.     end;
  404.     Copy$tlist := out
  405. end;
  406.  
  407. .endforeach
  408. {*******************************************************************
  409.  *    Read<type> and Read<type>list routines                       *
  410.  *******************************************************************}
  411.  
  412. { Forward declarations }
  413. .foreach t $(need_Read)
  414. function Read$t( var f, rf: text; var p: $t ): boolean; forward;
  415. .endforeach
  416. .foreach t $(need_Read_list)
  417. function Read$tlist( var f, rf: text; var p: $tlist ): boolean; forward;
  418. .endforeach
  419.  
  420. .foreach t $(need_Read)
  421. .if ${len ${telmlist $t}}
  422. .. Read tuple
  423. { Read a $t tuple from file 'f', and create an instance of
  424.   a Pascal structure for it. Set 'p' to this new structure.
  425. }
  426. function Read$t;
  427. var
  428. .foreach ename ${telmlist $t}
  429. .if ${eq list ${ttypeclass $t $(ename)}}
  430. .set tn ${ttypename $t $(ename)}list
  431. .else
  432. .set tn ${ttypename $t $(ename)}
  433. .endif
  434.     tmp$(ename): $(tn);
  435. .endforeach
  436.     err: boolean;
  437.  
  438. begin
  439.     p := nil;
  440.     err := tmneedc( f, rf, '(' );
  441. .set first 1
  442. .foreach ename ${telmlist $t}
  443. .if $(first)
  444. .set first 0
  445. .else
  446.     if not err then err := tmneedc( f, rf, ',' );
  447. .endif
  448. .if ${eq list ${ttypeclass $t $(ename)}}
  449. .set tn ${ttypename $t $(ename)}list
  450. .else
  451. .set tn ${ttypename $t $(ename)}
  452. .endif
  453.     if not err then err := Read$(tn)( f, rf, tmp$(ename) );
  454. .endforeach
  455.     if not err then begin
  456.     New$t( ${suffix , ${prefix tmp ${telmlist $t}}} p );
  457.     err := tmneedc( f, rf, ')' );
  458.     end;
  459.     Read$t := err
  460. end; { Read$t }
  461.  
  462. .else
  463. .. Read constructor
  464. .. Some internal calculations
  465. ..
  466. .. Determine the maximum length of the constructor names
  467. .. for this type
  468. .set maxclen 0
  469. .foreach c ${conslist $t}
  470. .set maxclen ${max $(maxclen) ${strlen $c}}
  471. .endforeach
  472. { Read a constructor $t from file 'f' and allocate space for it.
  473.   Set 'p' to that structure. }
  474. function Read$t;
  475. const
  476.     maxlen = $(maxclen);
  477.  
  478. type
  479.     consnm = packed array [1..maxlen] of char;
  480.  
  481. var
  482.     braccnt: integer;
  483.     word: consnm;
  484.     err: boolean;
  485.  
  486.     { Try to read a constructor name in buffer `buf' }
  487.     function readcons( var f, rf: text; var buf: consnm ): boolean;
  488.     var
  489.     ix: integer;
  490.     err: boolean;
  491.     busy: boolean;
  492.     alnumset: set of char;
  493.  
  494.     begin
  495.     alnumset := ['a'..'z','A'..'Z','0'..'9'];
  496.     buf := '${strpad "" $(maxclen) " "}';
  497.     ix := 1;
  498.     tmreadspc( f );
  499.     err := false;
  500.     if not (tmcurchar in alnumset) then begin
  501.         write( rf, 'expected $t constructor but got ' );
  502.         if tmcurchar = tmeofchar then
  503.         writeln( rf,  'EOF' )
  504.         else
  505.         writeln( rf,  'char with code ', ord( tmcurchar ):3 );
  506.         err := true
  507.     end;
  508.     busy := true;
  509.     while (not err) and busy and (tmcurchar in alnumset) do begin
  510.         if ix>maxlen then begin
  511.         writeln( rf,  '$t constructor name too long: "', buf, tmcurchar,'"' );
  512.         err := true
  513.         end
  514.         else begin
  515.         buf[ix] := tmcurchar;
  516.         tmgetc( f );
  517.         ix := ix+1
  518.         end;
  519.         if not (tmcurchar in alnumset) then
  520.         busy := false;
  521.     end;
  522.     readcons := err
  523.     end; { readcons }
  524.  
  525. .foreach c ${conslist $t}
  526.     { Constructor name '$c' was encountered in file 'f',
  527.       read remainder of constructor, and create an instance of
  528.       a Pascal structure for it. Set 'p' to this new structure.
  529.     }
  530.     function Read$c( var f, rf: text; var p: $t ): boolean;
  531.     var
  532. .foreach ename ${celmlist $t $c}
  533. .if ${eq list ${ctypeclass $t $c $(ename)}}
  534.     tmp$(ename): ${ctypename $t $c $(ename)}list;
  535. .else
  536.     tmp$(ename): ${ctypename $t $c $(ename)};
  537. .endif
  538. .endforeach
  539.     err: boolean;
  540.  
  541.     begin
  542.     err := false;
  543. .foreach ename ${celmlist $t $c}
  544. .if ${eq list ${ctypeclass $t $c $(ename)}}
  545. .set fn Read${ctypename $t $c $(ename)}list
  546. .else
  547. .set fn Read${ctypename $t $c $(ename)}
  548. .endif
  549.     if not err then err := $(fn)( f, rf, tmp$(ename) );
  550. .endforeach
  551.     if not err then New$c( ${suffix , ${prefix tmp ${celmlist $t $c}}} p );
  552.     Read$c := err
  553.     end;
  554.  
  555. .endforeach
  556. begin
  557.     p := nil;
  558.     tmreadobrac( f, braccnt );
  559.     err := readcons( f, rf, word );
  560.     if not err then begin
  561. .set els
  562. .foreach c ${conslist $t}
  563.     $(els)if word = '${strpad $c $(maxclen) " "}' then begin
  564.         err := Read$c( f, rf, p );
  565.     end
  566. .set els "else "
  567. .endforeach
  568.     else begin
  569.         writeln( rf, 'bad constructor for type $t: "', word, '"' );
  570.         err:=true
  571.     end;
  572.     end;
  573.     if not err then err := tmreadcbrac( f, rf, braccnt );
  574.     Read$t := err;
  575. end; { Read$t }
  576.  
  577. .endif
  578. .endforeach
  579. .foreach t $(need_Read_list)
  580. { Read an instance of a list of datastructure of type $t.
  581.   from file 'f' and allocate space for it. Set 'p' to
  582.   point to the list.
  583. }
  584. function Read$tlist;
  585. var
  586.     braccnt: integer;
  587.     n: $t;
  588.     err: boolean;
  589.     busy: boolean;
  590.  
  591. begin
  592.     p := nil;
  593.     tmreadobrac( f, braccnt );
  594.     err := tmneedc( f, rf, '[' );
  595.     if not err then tmreadspc( f );
  596.     busy := (tmcurchar <> ']');
  597.     while (busy and (not err)) do begin
  598.     err := Read$t( f, rf, n );
  599.     if not err then begin
  600.         p := App$t( p, n );
  601.         tmreadspc( f );
  602.         if( tmcurchar = ',' ) then
  603.         tmgetc( f )
  604.         else
  605.         busy := false
  606.     end
  607.     end;
  608.     if not err then err := tmneedc( f, rf, ']' );
  609.     if not err then err := tmreadcbrac( f, rf, braccnt );
  610.     Read$tlist := err
  611. end; { Read$tlist }
  612.  
  613. .endforeach
  614. {*******************************************************************
  615.  *    Cmp<type> and Cmp<type>list routines                         *
  616.  *******************************************************************}
  617.  
  618. { Forward declarations }
  619. .foreach t $(need_Cmp)
  620. function Cmp$t( a, b: $t ): integer; forward;
  621. .endforeach
  622. .foreach t $(need_Cmp_list)
  623. function Cmp$tlist( a, b: $tlist ): integer; forward;
  624. .endforeach
  625.  
  626. .foreach t $(need_Cmp)
  627. .if ${len ${telmlist $t}}
  628. .. Cmp tuple
  629. { Compare two $t tuples. }
  630. function Cmp$t;
  631. var
  632.     res: integer;
  633. begin
  634.     res := 0;
  635. .foreach ename ${telmlist $t}
  636. .if ${eq list ${ttypeclass $t $(ename)}}
  637. .set tn ${ttypename $t $(ename)}list
  638. .else
  639. .set tn ${ttypename $t $(ename)}
  640. .endif
  641.     if (res = 0) then res := Cmp$(tn)( a^.$(ename), b^.$(ename) );
  642. .endforeach
  643.     Cmp$t := res
  644. end; { Cmp$t }
  645.  
  646. .else
  647. .. Cmp tuple
  648. { Compare two $t constructors }
  649. function Cmp$t;
  650. var
  651.     res: integer;
  652. begin
  653.     res := 0;
  654.     if a^.tag>b^.tag then res := 1;
  655.     if a^.tag<b^.tag then res := -1;
  656.     if( res = 0 ) then begin
  657.     case a^.tag of
  658. .foreach c ${conslist $t}
  659.         Tag$c: begin
  660. .foreach ename ${celmlist $t $c}
  661. .if ${eq list ${ctypeclass $t $c $(ename)}}
  662. .set tn ${ctypename $t $c $(ename)}list
  663. .else
  664. .set tn ${ctypename $t $c $(ename)}
  665. .endif
  666.         if (res = 0) then res := Cmp$(tn)( a^.$(ename), b^.$(ename) );
  667. .endforeach
  668.         end;
  669. .endforeach
  670.     end;
  671.     end;
  672.     Cmp$t := res
  673. end; { Cmp$t }
  674.  
  675. .endif
  676. .endforeach
  677. .foreach t $(need_Cmp_list)
  678. { Compare two $t lists. }
  679. function Cmp$tlist;
  680. var
  681.     res: integer;
  682.  
  683. begin
  684.     res := 0;
  685.     while (res = 0) and ((a<>nil) or (b<>nil)) do begin
  686.     if (a=nil) then res := -1;
  687.     if (b=nil) then res := 1;
  688.     if( res = 0 ) then begin
  689.         res := Cmp$t( a, b );
  690.         a := a^.next;
  691.         b := b^.next;
  692.     end;
  693.     end;
  694.     Cmp$tlist := res
  695. end; { Cmp$tlist }
  696.  
  697. .endforeach
  698. { Initalizations for $(basename) }
  699. procedure Init$(basename);
  700. begin
  701.     tmeolnchar := chr( 10 );
  702.     tmeofchar := chr( 0 );
  703.     tmcurchar := tmeofchar;
  704. .if ${index Stat$(basename) $(need_misc)}
  705. .foreach t $(need_stat)
  706. .if ${len ${telmlist $t}}
  707.     CntNew$t := 0;
  708.     CntFre$t := 0;
  709. .else
  710. .foreach c ${conslist $t}
  711.     CntNew$c := 0;
  712.     CntFre$c := 0;
  713. .endforeach
  714. .endif
  715. .endforeach
  716. .endif
  717. end;
  718.  
  719. .if ${index Stat$(basename) $(need_misc)}
  720. {*******************************************************************
  721.  *    Statistics printing routines                                 *
  722.  *******************************************************************}
  723.  
  724. { give statistics }
  725. procedure Stat$(basename)( var f: text );
  726. const
  727.     al = ' allocated, ';
  728.     fr = ' freed.';
  729. begin
  730. .foreach t $(need_stat)
  731. .if ${len ${telmlist $t}}
  732.     write( f, '$t:':20, CntNew$t:6, al, CntFre$t:6, fr );
  733.     if CntNew$t = CntFre$t then
  734.     writeln( f )
  735.     else
  736.     writeln( f, ' <-' );
  737. .else
  738. .foreach c ${conslist $t}
  739.     write( f, '$c:':20, CntNew$c:6, al, CntFre$c:6, fr );
  740.     if CntNew$c = CntFre$c then
  741.     writeln( f )
  742.     else
  743.     writeln( f, ' <-' );
  744. .endforeach
  745. .endif
  746. .endforeach
  747. end;
  748.  
  749. .endif
  750. { ---- end of ${tplfilename} ---- }
  751.